using System.Collections.Generic;
using System.Text;
using UnityEngine;

namespace Kayac
{
	public class Model
	{
		public enum PrimitiveType
		{
			Triangles = 0,
			Quads = 1,
			Polygons = 2
		}

		public class PrimitiveList
		{
			private PrimitiveType type;

			private IReadOnlyList<int> indices;

			public PrimitiveType Type => default(PrimitiveType);

			public IReadOnlyList<int> Indices => null;

			public PrimitiveList(PrimitiveType type)
			{
			}

			public PrimitiveList(PrimitiveType type, IReadOnlyList<int> indices)
			{
			}

			public void SetIndices(IReadOnlyList<int> indices)
			{
			}
		}

		private List<Vertex> vertices;

		private Dictionary<PositionPair, HalfEdge> openEdges;

		private List<Face> faces;

		private Dictionary<Vector3, VertexPosition> vertexPositions;

		private bool valid;

		private Dictionary<Vertex, Vertex> vertexDic;

		public string Name { get; private set; }

		public int FaceCount => 0;

		public IEnumerable<VertexPosition> VertexPositions => null;

		public Model(string name)
		{
		}

		public Model(string name, Mesh mesh, float mergeNormalDistanceThreshold = -1f)
		{
		}

		public Model(string name, IReadOnlyList<Vector3> vertices, IReadOnlyList<Vector3> normals, IReadOnlyList<Vector4> tangents, IReadOnlyList<Vector2> uvs, IReadOnlyList<Color32> colors, IReadOnlyList<PrimitiveList> primitiveLists, float mergeNormalDistanceThreshold = -1f)
		{
		}

		public void Clear()
		{
		}

		public void ToArrays(List<Vector3> verticesOut, List<Vector3> normalsOut, List<Vector4> tangentsOut, List<Vector2> uvsOut, List<Color32> colorsOut, List<PrimitiveList> primitiveListsOut)
		{
		}

		public void FillMeshPN(Mesh dst)
		{
		}

		public void FillMeshPNT(Mesh dst)
		{
		}

		public void FillMeshPNTT(Mesh dst)
		{
		}

		public void Purtuabate(float width)
		{
		}

		public void SharpenEdges()
		{
		}

		public void Cut(Model front, Model back, Plane plane, float onPlaneTorrelance, int cutFacePrimitiveListIndex, Vector2 cutFaceUvCenter, float cutFaceUvScale)
		{
		}

		public bool IsClosed(bool fullCheck)
		{
			return false;
		}

		public string Dump()
		{
			return null;
		}

		public Bounds CalcBounds()
		{
			return default(Bounds);
		}

		public float CalcMaxDistanceFrom(Vector3 p)
		{
			return 0f;
		}

		public float CalcSurfaceArea()
		{
			return 0f;
		}

		private void CloseCutPlane(CutData cutData, Plane plane, float onPlaneTorrelance, Vector2 cutFaceUvCenter, float cutFaceUvScale, int cutFacePrimitiveListIndex)
		{
		}

		private bool IsAllFaceConvex()
		{
			return false;
		}

		private void Initialize(IReadOnlyList<Vector3> vertices, IReadOnlyList<Vector3> normals, IReadOnlyList<Vector4> tangents, IReadOnlyList<Vector2> uvs, IReadOnlyList<Color32> colors, IReadOnlyList<PrimitiveList> primitiveLists, float mergeNormalDistanceThreshold)
		{
		}

		private void MergePolygons(float normalDistanceThreshold)
		{
		}

		private string DumpOpenEdges(bool fullCheck)
		{
			return null;
		}

		private void InitializeContainers()
		{
		}

		private void AddCutFace(CutData cutData, Plane plane, float onPlaneTorrelance, Vector2 uvCenter, float uvScale, int primitiveListIndex, HashSet<HalfEdge> cutEdges, bool againstPlane)
		{
		}

		private void DivideToConvex(Face face, CutData cutData)
		{
		}

		private bool CarveTriangleFrom(Face face, CutData cutData)
		{
			return false;
		}

		private bool TryCarveTriangleFrom(Face face, HalfEdge centerEdge, CutData cutData)
		{
			return false;
		}

		private Face CreateCutFace(CutData cutData, Plane plane, Vector2 uvCenter, float uvScale, int primitiveListIndex, bool againstPlane)
		{
			return null;
		}

		private bool FindCutEdgeLoop(CutData cutData, Plane plane, float onPlaneTorrelance, HashSet<HalfEdge> cutEdges)
		{
			return false;
		}

		private Face AddCopy(Face srcFace, CutData cutData)
		{
			return null;
		}

		private Vertex GetOrCreateVertexCopy(Vertex src)
		{
			return null;
		}

		private VertexPosition GetOrCreateVertexPositionCopy(Vector3 positionValue, Vertex vertex)
		{
			return null;
		}

		private void AddTriangle(int vertexIndex0, int vertexIndex1, int vertexIndex2, int primitiveListIndex)
		{
		}

		private void AddPolygon(int vertexCount, IReadOnlyList<int> indices, int indexOffset, int primitiveListIndex)
		{
		}

		private void ConnectEdges(HalfEdge e)
		{
		}

		private bool CutFaceConvex(Model frontModel, Model backModel, Face srcFace, Plane plane, float onPlaneTorrelance, CutData cutData)
		{
			return false;
		}

		private bool CheckFace(Face face, float areaThreshold, bool warnAsError = false)
		{
			return false;
		}

		private Face CreateEmptyFace(int primitiveListIndex)
		{
			return null;
		}

		private Face CreateEmptyFace(int primitiveListIndex, Vector3 normal)
		{
			return null;
		}

		private Face CreateEmptyFace(Face srcFace)
		{
			return null;
		}

		private void AddVertexCopyToFace(Face face, Vertex srcV)
		{
		}

		private void CloseFace(Face face)
		{
		}

		private bool Validate(StringBuilder sb)
		{
			return false;
		}

		private void FillMeshIndices(Mesh dst, IReadOnlyList<PrimitiveList> primitiveLists)
		{
		}
	}
}
